#pragma once

#include "viml/value.h"
#include <cmath>
#include <climits>

namespace viml {

/**
 * VM专用的内联优化函数
 * 避免虚函数调用开销，提供最高性能的类型检查
 */

// 内联的快速数值类型检查
inline bool is_number_fast(const Value& v) {
    // 直接检查bits而不是调用虚函数
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_NUMBER;
}

// 内联的快速浮点类型检查
inline bool is_float_fast(const Value& v) {
    // 检查是否不是NaN（即为有效的double）
    return !v.is_nan_debug();
}

// 内联的快速布尔类型检查
inline bool is_boolean_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_BOOLEAN;
}

// 内联的快速字符串类型检查
inline bool is_string_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_STRING;
}

// 内联的快速nil类型检查
inline bool is_nil_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_NIL;
}

// 内联的快速列表类型检查
inline bool is_list_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_LIST;
}

// 内联的快速字典类型检查
inline bool is_dict_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_DICT;
}

// 内联的快速函数类型检查
inline bool is_function_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_FUNCTION;
}

// 内联的快速内建函数类型检查
inline bool is_builtin_fast(const Value& v) {
    return (v.raw_bits() & Value::QNAN_MASK) == Value::QNAN_MASK &&
           (v.raw_bits() & Value::TYPE_MASK) == Value::TAG_BUILTIN;
}

// 组合检查：数值或浮点（用于算术运算）
inline bool is_numeric_fast(const Value& v) {
    if (!v.is_nan_debug()) {
        return true;  // 浮点数
    }
    uint64_t tag = v.raw_bits() & Value::TYPE_MASK;
    return tag == Value::TAG_NUMBER;
}

// 快速数值提取（避免异常检查）
inline double extract_number_fast(const Value& v) {
    if (!v.is_nan_debug()) {
        // 浮点数，直接转换
        return v.as_float();
    } else {
        // 整数，需要从bits中提取
        return static_cast<double>(v.as_number());
    }
}

// 快速Value创建（避免构造函数开销）
inline Value make_boolean_fast(bool b) {
    return Value::boolean(b);
}

inline Value make_number_fast(double n) {
    // 如果是整数，使用数值类型存储
    if (n == std::floor(n) && n >= INT64_MIN && n <= INT64_MAX) {
        return Value::make_number(static_cast<int64_t>(n));
    } else {
        return Value::make_float(n);
    }
}

} // namespace viml

namespace viml {

/**
 * 常量池优化类
 * 预分配常用数值对象，减少Value构造开销
 */
class ConstantPool {
private:
    static constexpr int MIN_CACHED = -10;
    static constexpr int MAX_CACHED = 100;
    static constexpr int CACHE_SIZE = MAX_CACHED - MIN_CACHED + 1;
    
    static Value cached_numbers[CACHE_SIZE];
    static Value cached_booleans[2];  // true, false
    static Value cached_nil;
    static bool initialized;
    
public:
    static void initialize() {
        if (initialized) return;
        
        // 预分配常用数值 (-10 到 100)
        for (int i = MIN_CACHED; i <= MAX_CACHED; ++i) {
            cached_numbers[i - MIN_CACHED] = Value::make_number(i);
        }
        
        // 预分配布尔值
        cached_booleans[0] = Value::boolean(false);
        cached_booleans[1] = Value::boolean(true);
        
        // 预分配nil
        cached_nil = Value::nil();
        
        initialized = true;
    }
    
    static const Value& get_number(int64_t n) {
        if (n >= MIN_CACHED && n <= MAX_CACHED) {
            return cached_numbers[n - MIN_CACHED];
        }
        // 超出范围，创建新对象
        static thread_local Value temp;
        temp = Value::make_number(n);
        return temp;
    }
    
    static const Value& get_boolean(bool b) {
        return cached_booleans[b ? 1 : 0];
    }
    
    static const Value& get_nil() {
        return cached_nil;
    }
    
    static bool is_cacheable_number(int64_t n) {
        return n >= MIN_CACHED && n <= MAX_CACHED;
    }
};

// 静态成员定义
inline Value ConstantPool::cached_numbers[CACHE_SIZE];
inline Value ConstantPool::cached_booleans[2];
inline Value ConstantPool::cached_nil;
inline bool ConstantPool::initialized = false;

} // namespace viml